using System;
using System.Collections.Generic;
using System.Data.SqlClient;
using System.IO;
using System.Web;
using AEL.ACT;
using AEL.BOD;
using BEL;
    
namespace DEL.BOD
{
    /// <summary>
    /// Acceso a la base de datos
    /// Modulo:Bodega tar
    /// Tabla:Bod_Archivo_Plano
    /// Permite crear y borrar un registro en la tabla Bod_Archivo_Plano_Documento
    /// al insertar o borrar un registro de archivo plano
    /// </summary>
    public class DO_Bod_Archivo_Plano
    {
    #region Adapter
        private static CEL.BOD.DO_Bod_Archivo_Plano _adpBod_Archivo_Plano;
        private static CEL.BOD.DO_Bod_Archivo_Plano adpBod_Archivo_Plano
        {
            get
            {
                if (_adpBod_Archivo_Plano == null)
                    _adpBod_Archivo_Plano = new CEL.BOD.DO_Bod_Archivo_Plano();
                return _adpBod_Archivo_Plano;
            }
        }

        private static CEL.BOD.DO_Bod_Archivo_Plano_Documento _adpBod_Archivo_Plano_Documento;
        private static CEL.BOD.DO_Bod_Archivo_Plano_Documento adpBod_Archivo_Plano_Documento
        {
            get
            {
                if (_adpBod_Archivo_Plano_Documento == null)
                    _adpBod_Archivo_Plano_Documento = new CEL.BOD.DO_Bod_Archivo_Plano_Documento();
                return _adpBod_Archivo_Plano_Documento;
            }

        }

        private static CEL.BOD.DO_Bod_Archivo_Plano_Det _adpBod_Archivo_Plano_Det;
        private static CEL.BOD.DO_Bod_Archivo_Plano_Det adpBod_Archivo_Plano_Det
        {
            get
            {
                if (_adpBod_Archivo_Plano_Det == null)
                    _adpBod_Archivo_Plano_Det = new CEL.BOD.DO_Bod_Archivo_Plano_Det();
                return _adpBod_Archivo_Plano_Det;
            }
        }

        private static CEL.COM.DO_Com_Articulo_Barra _adpCom_Articulo_Barra;
        private static CEL.COM.DO_Com_Articulo_Barra adpCom_Articulo_Barra
        {
            get
            {
                if (_adpCom_Articulo_Barra == null)
                    _adpCom_Articulo_Barra = new CEL.COM.DO_Com_Articulo_Barra();
                return _adpCom_Articulo_Barra;
            }
        }

        private static CEL.BOD.DO_Bod_Conteo_Fisico _adpBod_Conteo_Fisico;
        private static CEL.BOD.DO_Bod_Conteo_Fisico adpBod_Conteo_Fisico
        {
            get
            {
                if (_adpBod_Conteo_Fisico == null)
                    _adpBod_Conteo_Fisico = new CEL.BOD.DO_Bod_Conteo_Fisico();
                return _adpBod_Conteo_Fisico;
            }

        }

        private static CEL.BOD.DO_Bod_Conteo_Fisico_Det _adpConteo_Fisico_Det;
        private static CEL.BOD.DO_Bod_Conteo_Fisico_Det adpConteo_Fisico_Det
        {
            get
            {
                if (_adpConteo_Fisico_Det == null)
                    _adpConteo_Fisico_Det = new CEL.BOD.DO_Bod_Conteo_Fisico_Det();
                return _adpConteo_Fisico_Det;
            }

        }
    #endregion
    
    #region Operaciones con datos
        public static string Insert(Scope s, Bod_Archivo_Plano oBod_Archivo_Plano)
        {
            // Inserto los objetos
            string resultado;
            try
            {
                adpBod_Archivo_Plano.Adapter.BeginTransaction();
                adpBod_Archivo_Plano_Documento.Adapter.Transaction = adpBod_Archivo_Plano.Adapter.Transaction;

                // Insertar el Archivo Plano
                resultado = adpBod_Archivo_Plano.Insert(s, oBod_Archivo_Plano);

                //Inserta el Documento del archivo Plano

                Bod_Archivo_Plano_Documento oBod_Archivo_Plano_Documento = new Bod_Archivo_Plano_Documento();

                oBod_Archivo_Plano_Documento.Bod_Archivo_Plano_Id = oBod_Archivo_Plano.Id;
                oBod_Archivo_Plano_Documento.Extension = null;
                oBod_Archivo_Plano_Documento.Origen_Path = null;
                oBod_Archivo_Plano_Documento.Origen_Nombre = null;
                oBod_Archivo_Plano_Documento.Estado = null;

                adpBod_Archivo_Plano_Documento.Insert(s, oBod_Archivo_Plano_Documento);
                
                adpBod_Archivo_Plano.Adapter.CommitTransaction();
            }
            catch (Exception e)
            {
                adpBod_Archivo_Plano.Adapter.RollbackTransaction();
                throw (e);
            }
            return resultado;
        }
        
        public static int Delete(Scope s,  Bod_Archivo_Plano o)
        {
            int resultado = 0;
            try
            {
                adpBod_Archivo_Plano.Adapter.BeginTransaction();
                adpBod_Archivo_Plano_Documento.Adapter.Transaction = adpBod_Archivo_Plano.Adapter.Transaction;
                
                // Obtener la lista de Archivos Planos  
                List<Bod_Archivo_Plano_Documento> Archivo_Plano_Documento =
                    adpBod_Archivo_Plano_Documento.GetByArchivo(s, o.Id);

                // Borra el documento del archivo plano
                adpBod_Archivo_Plano_Documento.Delete(s, Archivo_Plano_Documento[0]);
              
                // Borra el archivo plano
                resultado = adpBod_Archivo_Plano.Delete(s, o);
                
                adpBod_Archivo_Plano.Adapter.CommitTransaction();
            }
            catch (Exception e)
            {
                adpBod_Archivo_Plano.Adapter.RollbackTransaction();
                throw (e);
            }
            return resultado;
        }
        
        public static void Insert_Datos(Scope s, Bod_Archivo_Plano p_Objeto)
        {
            try
            {
                adpBod_Archivo_Plano_Det.Adapter.BeginTransaction();

                List<Bod_Archivo_Plano_Det> lstBod_Archivo_Plano_Det = GetFromFile(p_Objeto, s);
                foreach (Bod_Archivo_Plano_Det bodArchivoPlanoDet in lstBod_Archivo_Plano_Det)
                {
                    try
                    {
                        adpBod_Archivo_Plano_Det.Insert(s, bodArchivoPlanoDet);
                    }
                    catch(Exception e)
                    {                        
                        EmitirExcepcion(TXT_Mensajes._MSJ14, e.Message); 
                    }
                }
                adpBod_Archivo_Plano_Det.Adapter.CommitTransaction();
            }
            catch (Exception e)
            {
                adpBod_Archivo_Plano_Det.Adapter.RollbackTransaction();
                throw (e);
            }
        }

        public static void EmitirExcepcion(string mensaje, string caso)
        {
            Exception eCaso = new System.Exception(caso);
            Exception otroEX = new System.Exception(mensaje, eCaso);
            throw otroEX;
        }
        
        public static List<Bod_Archivo_Plano_Det> GetFromFile(Bod_Archivo_Plano p_Objeto, Scope s)
        {
            List<Bod_Archivo_Plano_Det> lstBodArchivoPlanoDet = null;
            StreamReader strLectura = null;
            using (strLectura)
            {
                try
                {
                    strLectura = new StreamReader(
                        HttpContext.Current.Server.MapPath(p_Objeto.Destino_Ruta_Nombre));
                }
                catch (Exception e)
                {
                    EmitirExcepcion(TXT_Mensajes._MSJ42, e.Message);
                }

                int secuencia = 1;
                lstBodArchivoPlanoDet = new List<Bod_Archivo_Plano_Det>();
                while (!strLectura.EndOfStream)
                {
                    string strLinea = strLectura.ReadLine();
                    Bod_Archivo_Plano_Det archivoPlanoDet = ProcesarLinea(strLinea, s, secuencia);
                    archivoPlanoDet.Secuencial = secuencia;
                    archivoPlanoDet.Bod_Archivo_Plano_Id = p_Objeto.Id;
                    lstBodArchivoPlanoDet.Add(archivoPlanoDet);
                    secuencia++;
                }
                strLectura.Close();
            }
            return lstBodArchivoPlanoDet;
        }

        private static readonly char[] _SPLIT =  { '|' };

        private static Bod_Archivo_Plano_Det ProcesarLinea(string linea, Scope s, int secuencia)
        {
            string[] datos = linea.Split(_SPLIT);
            if (datos.Length < 2)
                EmitirExcepcion(TXT_Mensajes._MSJ44, "");
            Bod_Archivo_Plano_Det objetoArchivo = new Bod_Archivo_Plano_Det();
            objetoArchivo.Com_Articulo_Barra_Codigo_Barra = datos[0].Trim();
            ValidarCom_Articulo_Barra_Codigo_Barra(objetoArchivo.Com_Articulo_Barra_Codigo_Barra, s, secuencia);
            try
            {
                objetoArchivo.Cantidad = Convert.ToDecimal(datos[1].Trim());
            }
            catch (Exception e)
            {
                EmitirExcepcion(TXT_Mensajes._MSJ43, secuencia.ToString());
            }
            return objetoArchivo;
        }

        private static void ValidarCom_Articulo_Barra_Codigo_Barra(string codigoBarra, Scope s, int secuencia)
        {
            List<AEL.COM.Com_Articulo_Barra> lstArticuloBarra = null;
            try
            {
                lstArticuloBarra = adpCom_Articulo_Barra.GetByCodigoBarra(s, codigoBarra);
            }
            catch (Exception e)
            {
                EmitirExcepcion(TXT_Mensajes._MSJ44, secuencia.ToString());
            }
            if (lstArticuloBarra.Count != 1)
                EmitirExcepcion(TXT_Mensajes._MSJ44, secuencia.ToString());
        }

        public static void Insert_Conteo_Fisico(Scope s, ref Bod_Archivo_Plano p_Objeto)
        {
            try
            {
                adpBod_Conteo_Fisico.Adapter.BeginTransaction();
                adpConteo_Fisico_Det.Adapter.Transaction = adpBod_Conteo_Fisico.Adapter.Transaction;
                adpBod_Archivo_Plano.Adapter.Transaction = adpBod_Conteo_Fisico.Adapter.Transaction;

                Bod_Conteo_Fisico bodConteoFisico = new Bod_Conteo_Fisico();
                bodConteoFisico.Tipo = "PLA";
                bodConteoFisico.Estado = "PEN";
                bodConteoFisico.Fecha_Creacion = DateTime.Now;
                bodConteoFisico.Creacion_Per_Personal_Id = s.Per_Personal_Id;
                bodConteoFisico.Fecha_Update = DateTime.Now;
                bodConteoFisico.Update_Per_Personal_Id = s.Per_Personal_Id;
                bodConteoFisico.Descripcion = p_Objeto.Descripcion;
                bodConteoFisico.Bod_Bodega_Id = p_Objeto.Bod_Bodega_Id;
                bodConteoFisico.Fecha_Conteo = p_Objeto.Fecha_Conteo;

                string IDConteoFisico = adpBod_Conteo_Fisico.Insert(s, bodConteoFisico);
                List<Bod_Archivo_Plano_Det> lstBodArchivoPlanoDet = adpBod_Archivo_Plano_Det.GetByArchivo(s, p_Objeto.Id);

                foreach (Bod_Archivo_Plano_Det bodArchivoPlanoDet in lstBodArchivoPlanoDet)
                {
                    Bod_Conteo_Fisico_Det BodConteoFisicoDet = new Bod_Conteo_Fisico_Det();
                    BodConteoFisicoDet.Bod_Conteo_Fisico_Id = IDConteoFisico;
                    if (bodArchivoPlanoDet.Com_Articulo_Id != null)
                    {
                        BodConteoFisicoDet.Com_Articulo_Id = bodArchivoPlanoDet.Com_Articulo_Id;
                    }
                    else
                    {
                        EmitirExcepcion(TXT_Mensajes._MSJ45, bodArchivoPlanoDet.Secuencial.ToString());
                    }

                    if (bodArchivoPlanoDet.Bod_Unidad_Id != null)
                    {
                        BodConteoFisicoDet.Bod_Unidad_Id = bodArchivoPlanoDet.Bod_Unidad_Id;
                    }
                    else
                    {                        
                        EmitirExcepcion(TXT_Mensajes._MSJ46, bodArchivoPlanoDet.Secuencial.ToString());
                    }
                    BodConteoFisicoDet.Cantidad = bodArchivoPlanoDet.Cantidad;
                    try
                    {
                        adpConteo_Fisico_Det.Insert(s, BodConteoFisicoDet);
                    }
                    catch
                    {                       
                        EmitirExcepcion(TXT_Mensajes._MSJ47, bodArchivoPlanoDet.Secuencial.ToString()); 
                    }

                }

                Bod_Archivo_Plano nuevoObjeto = CopiarArchivoPlano(p_Objeto);

                nuevoObjeto.Bod_Conteo_Fisico_Id = IDConteoFisico;

                adpBod_Archivo_Plano.Update(s, nuevoObjeto, p_Objeto);

                p_Objeto = nuevoObjeto;

                adpBod_Conteo_Fisico.Adapter.CommitTransaction();
            }
            catch(Exception e)
            {
                adpBod_Conteo_Fisico.Adapter.RollbackTransaction();
                throw (e);
            }
                  
        }

        private static Bod_Archivo_Plano CopiarArchivoPlano(Bod_Archivo_Plano p_Objeto)
        {
            return new Bod_Archivo_Plano(p_Objeto);
        }

        public static void Delete_Archivo(Scope s, Bod_Archivo_Plano p_Objeto)
        {

            List<Bod_Archivo_Plano_Documento> lstBodArchivoPlanoDocumento = adpBod_Archivo_Plano_Documento.GetByArchivo(s, p_Objeto.Id);
            Bod_Archivo_Plano_Documento bodArchivoPlanoDocumento = lstBodArchivoPlanoDocumento[0];
            
            Bod_Archivo_Plano_Documento nuevoObjeto = 
                new Bod_Archivo_Plano_Documento(bodArchivoPlanoDocumento.Id,bodArchivoPlanoDocumento.Codigo,bodArchivoPlanoDocumento.Estado,bodArchivoPlanoDocumento.Bod_Archivo_Plano_Id,bodArchivoPlanoDocumento.Extension,
                bodArchivoPlanoDocumento.Origen_Path,bodArchivoPlanoDocumento.Origen_Nombre,bodArchivoPlanoDocumento.Bod_Archivo_Plano_Id,bodArchivoPlanoDocumento.Bod_Bodega_Id,bodArchivoPlanoDocumento.Bod_Bodega_Codigo,
                bodArchivoPlanoDocumento.Bod_Bodega_Nombre,bodArchivoPlanoDocumento.Creacion_Per_Personal_Id,bodArchivoPlanoDocumento.Creacion_Per_Personal_Codigo,bodArchivoPlanoDocumento.Creacion_Per_Personal_Nombre,
                bodArchivoPlanoDocumento.Update_Per_Personal_Id,bodArchivoPlanoDocumento.Update_Per_Personal_Codigo,bodArchivoPlanoDocumento.Update_Per_Personal_Nombre,bodArchivoPlanoDocumento.Int_Empresa_Id,
                bodArchivoPlanoDocumento.Int_Empresa_Codigo,bodArchivoPlanoDocumento.Int_Empresa_Nombre,bodArchivoPlanoDocumento.Path_Destino,bodArchivoPlanoDocumento.Destino_Nombre,bodArchivoPlanoDocumento.Estado_nombre
                );
            
            nuevoObjeto.Extension = null;
            nuevoObjeto.Origen_Path = null;
            nuevoObjeto.Origen_Nombre = null;
           
            if(adpBod_Archivo_Plano_Documento.Update(s,nuevoObjeto, bodArchivoPlanoDocumento)==1)
            {
                File.Delete(HttpContext.Current.Server.MapPath(bodArchivoPlanoDocumento.Path_Destino));
            }
        }

        public static void Delete_Con_Detalles(Scope s, Bod_Archivo_Plano p_Objeto)
        {
            try
            {
                adpBod_Archivo_Plano_Det.Adapter.BeginTransaction();

                List<Bod_Archivo_Plano_Det> lstBodArchivoPlanoDet = adpBod_Archivo_Plano_Det.GetByArchivo(s, p_Objeto.Id);
                foreach (Bod_Archivo_Plano_Det bodArchivoPlanoDet in lstBodArchivoPlanoDet)
                {                    
                        adpBod_Archivo_Plano_Det.Delete(s, bodArchivoPlanoDet);                    
                }
                adpBod_Archivo_Plano_Det.Adapter.CommitTransaction();
            }
            catch (Exception e)
            {
                adpBod_Archivo_Plano_Det.Adapter.RollbackTransaction();
                throw (e);
            }
        }

        public static void Delete_conteo_Fisico(Scope s, ref Bod_Archivo_Plano p_Objeto)
        {
            try
            {
                adpBod_Conteo_Fisico.Adapter.BeginTransaction();
                adpConteo_Fisico_Det.Adapter.Transaction = adpBod_Conteo_Fisico.Adapter.Transaction;
                adpBod_Archivo_Plano.Adapter.Transaction = adpBod_Conteo_Fisico.Adapter.Transaction;

                List<Bod_Conteo_Fisico> lstBodConteoFisico = adpBod_Conteo_Fisico.GetById(s, p_Objeto.Bod_Conteo_Fisico_Id);
                Bod_Conteo_Fisico bodConteoFisico = lstBodConteoFisico[0];

                if (bodConteoFisico.Estado == "PEN")
                {
                    List<Bod_Conteo_Fisico_Det> lstBodConteoFisicoDet = null;
                   
                        lstBodConteoFisicoDet = adpConteo_Fisico_Det.GetByConteo(s, bodConteoFisico.Id);
                   
                    foreach (Bod_Conteo_Fisico_Det bodConteoFisicoDet in lstBodConteoFisicoDet)
                    {
                        adpConteo_Fisico_Det.Delete(s, bodConteoFisicoDet);

                    }

                    Bod_Archivo_Plano nuevoArchivoPlano = CopiarArchivoPlano(p_Objeto);
                    nuevoArchivoPlano.Bod_Conteo_Fisico_Id = null;

                    adpBod_Archivo_Plano.Update(s, nuevoArchivoPlano, p_Objeto);

                    p_Objeto = nuevoArchivoPlano;

                    adpBod_Conteo_Fisico.Delete(s, bodConteoFisico);

                }
                else
                {                   
                    EmitirExcepcion(TXT_Mensajes._MSJ48, "");
                }
                adpBod_Conteo_Fisico.Adapter.CommitTransaction();
            }
            catch (Exception e)
            {
                adpBod_Conteo_Fisico.Adapter.RollbackTransaction();
                throw (e);
            }
        }
    #endregion

    }
}
